static inline void
tidy_stylable_get_property_internal (TidyStylable *stylable,
GParamSpec *pspec,
GValue *value)
{
TidyStyle *style;
GValue real_value = { 0, };
gchar *real_name;
real_name = g_strconcat (g_param_spec_get_qdata (pspec, quark_real_owner),
"::",
pspec->name,
NULL);
style = tidy_stylable_get_style (stylable);
if (!tidy_style_has_property (style, real_name))
{
/* the style has no property set, use the default value
* from the GParamSpec
*/
g_param_value_set_default (pspec, value);
g_free (real_name);
return;
}
tidy_style_get_property (style, real_name, &real_value);
g_value_copy (&real_value, value);
g_value_unset (&real_value);
g_free (real_name);
}
GstVaapiEncoderStatus
gst_vaapi_encoder_set_property (GstVaapiEncoder * encoder, gint prop_id,
const GValue * value)
{
GstVaapiEncoderStatus status;
GValue default_value = G_VALUE_INIT;
g_return_val_if_fail (encoder != NULL,
GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER);
if (!value) {
GParamSpec *const pspec = prop_find_pspec (encoder, prop_id);
if (!pspec)
goto error_invalid_property;
g_value_init (&default_value, pspec->value_type);
g_param_value_set_default (pspec, &default_value);
value = &default_value;
}
status = set_property (encoder, prop_id, value);
if (default_value.g_type)
g_value_unset (&default_value);
return status;
/* ERRORS */
error_invalid_property:
{
GST_ERROR ("unsupported property (%d)", prop_id);
return GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER;
}
}
static void
check_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);
}
/**
* gimp_rc_migrate:
* @rc: a #GimpRc object.
*
* Resets all GimpParamConfigPath properties of the passed rc object
* to their default values, in order to prevent paths in a migrated
* gimprc to refer to folders in the old GIMP's user directory.
**/
void
gimp_rc_migrate (GimpRc *rc)
{
GParamSpec **pspecs;
guint n_pspecs;
gint i;
g_return_if_fail (GIMP_IS_RC (rc));
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (rc), &n_pspecs);
for (i = 0; i < n_pspecs; i++)
{
GParamSpec *pspec = pspecs[i];
if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec))
{
GValue value = { 0, };
g_value_init (&value, pspec->value_type);
g_param_value_set_default (pspec, &value);
g_object_set_property (G_OBJECT (rc), pspec->name, &value);
g_value_unset (&value);
}
}
g_free (pspecs);
}
int
ce_get_property_default (NMSetting *setting, const char *property_name)
{
GParamSpec *spec;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_SETTING (setting), -1);
spec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), property_name);
g_return_val_if_fail (spec != NULL, -1);
g_value_init (&value, spec->value_type);
g_param_value_set_default (spec, &value);
if (G_VALUE_HOLDS_CHAR (&value))
return (int) g_value_get_schar (&value);
else if (G_VALUE_HOLDS_INT (&value))
return g_value_get_int (&value);
else if (G_VALUE_HOLDS_INT64 (&value))
return (int) g_value_get_int64 (&value);
else if (G_VALUE_HOLDS_LONG (&value))
return (int) g_value_get_long (&value);
else if (G_VALUE_HOLDS_UINT (&value))
return (int) g_value_get_uint (&value);
else if (G_VALUE_HOLDS_UINT64 (&value))
return (int) g_value_get_uint64 (&value);
else if (G_VALUE_HOLDS_ULONG (&value))
return (int) g_value_get_ulong (&value);
else if (G_VALUE_HOLDS_UCHAR (&value))
return (int) g_value_get_uchar (&value);
g_return_val_if_fail (FALSE, 0);
return 0;
}
/* Retrieve a gchar* property from the preferences ini file. If an error occurs (usually because
the preferences file does not exist, or the key value is not present, then the default value
in the g_param_spec is used instead */
static gchar*
mame_gui_prefs_get_string_property_from_key_file (MameGuiPrefs *pr, gchar *property) {
GError *error = NULL;
gchar* val;
val = g_key_file_get_string (pr->priv->prefs_ini_file, "Preferences", property, &error);
if (error) {
GMAMEUI_DEBUG ("Error retrieving string UI option %s - %s", property, error->message);
g_error_free (error);
error = NULL;
GParamSpec *spec;
GValue value = { 0, };
spec = g_object_class_find_property (G_OBJECT_GET_CLASS (pr), property);
g_value_init (&value, G_TYPE_STRING);
g_param_value_set_default (spec, &value);
val = g_strdup (g_value_get_string (&value));
GMAMEUI_DEBUG (_("Retrieving default string value for %s: %s"), property, val);
}
return val;
}
static void
test_defaults (GType type, const char *name)
{
GParamSpec **property_specs;
guint n_property_specs;
GObject *setting;
int i;
setting = g_object_new (type, NULL);
property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (setting), &n_property_specs);
ASSERT (property_specs != NULL,
name, "couldn't find property specs for object of type '%s'",
g_type_name (G_OBJECT_TYPE (setting)));
for (i = 0; i < n_property_specs; i++) {
GParamSpec *prop_spec = property_specs[i];
GValue value = G_VALUE_INIT;
GValue defvalue = G_VALUE_INIT;
char *actual, *expected;
gboolean ok = FALSE;
/* Ignore non-fundamental types since they won't really have
* defaults.
*/
if (!G_TYPE_IS_FUNDAMENTAL (prop_spec->value_type))
continue;
g_value_init (&value, prop_spec->value_type);
g_object_get_property (G_OBJECT (setting), prop_spec->name, &value);
g_value_init (&defvalue, prop_spec->value_type);
g_param_value_set_default (prop_spec, &defvalue);
actual = g_strdup_value_contents (&value);
expected = g_strdup_value_contents (&defvalue);
if (!strcmp (prop_spec->name, NM_SETTING_NAME)) {
/* 'name' is always the setting name, not the default value */
ok = !strcmp (nm_setting_get_name (NM_SETTING (setting)), name);
g_free (expected);
expected = g_strdup (name);
} else
ok = g_param_value_defaults (prop_spec, &value);
ASSERT (ok,
name, "property '%s' value '%s' not the expected default value '%s'",
prop_spec->name, actual, expected);
g_free (actual);
g_free (expected);
g_value_unset (&value);
g_value_unset (&defvalue);
}
g_free (property_specs);
g_object_unref (setting);
}
static void
gst_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;
}
static GObject*
base_object_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
/* The constructor is the one place where a GParamSpecOverride is visible
* to the outside world, so we do a bunch of checks here
*/
GValue value1 = { 0, };
GValue value2 = { 0, };
GParamSpec *pspec;
g_assert (n_construct_properties == 1);
pspec = construct_properties->pspec;
/* Check we got the param spec we expected
*/
g_assert (G_IS_PARAM_SPEC_OVERRIDE (pspec));
g_assert (pspec->param_id == BASE_PROP1);
g_assert (strcmp (g_param_spec_get_name (pspec), "prop1") == 0);
g_assert (g_param_spec_get_redirect_target (pspec) == iface_spec1);
/* Test redirection of the nick and blurb to the redirect target
*/
g_assert (strcmp (g_param_spec_get_nick (pspec), "Prop1") == 0);
g_assert (strcmp (g_param_spec_get_blurb (pspec), "Property 1") == 0);
/* Test forwarding of the various GParamSpec methods to the redirect target
*/
g_value_init (&value1, G_TYPE_INT);
g_value_init (&value2, G_TYPE_INT);
g_param_value_set_default (pspec, &value1);
g_assert (g_value_get_int (&value1) == 42);
g_value_reset (&value1);
g_value_set_int (&value1, 0x10000);
g_assert (g_param_value_validate (pspec, &value1));
g_assert (g_value_get_int (&value1) == 0xFFFF);
g_assert (!g_param_value_validate (pspec, &value1));
g_value_reset (&value1);
g_value_set_int (&value1, 1);
g_value_set_int (&value2, 2);
g_assert (g_param_values_cmp (pspec, &value1, &value2) < 0);
g_assert (g_param_values_cmp (pspec, &value2, &value1) > 0);
g_value_unset (&value1);
g_value_unset (&value2);
return base_parent_class->constructor (type,
n_construct_properties,
construct_properties);
}
static void
set_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 VALUE
value_default(VALUE self)
{
GValue tmp = {0,};
VALUE result;
g_value_init(&tmp,
G_PARAM_SPEC_VALUE_TYPE(rbgobj_get_param_spec(self)));
g_param_value_set_default(rbgobj_get_param_spec(self), &tmp);
result = rbgobj_gvalue_to_rvalue(&tmp);
g_value_unset(&tmp);
return result;
}
static void
commit_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 void
terminal_profile_reset_property_internal (TerminalProfile *profile,
GParamSpec *pspec,
gboolean notify)
{
TerminalProfilePrivate *priv = profile->priv;
GValue value_ = { 0, };
GValue *value;
if (notify)
{
value = &value_;
g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec));
}
else
value = g_value_array_get_nth (priv->properties, pspec->param_id);
g_assert (value != NULL);
/* A few properties don't have defaults via the param spec; set them explicitly */
switch (pspec->param_id)
{
case PROP_FOREGROUND_COLOR:
case PROP_BOLD_COLOR:
g_value_set_boxed (value, &DEFAULT_FOREGROUND_COLOR);
break;
case PROP_BACKGROUND_COLOR:
g_value_set_boxed (value, &DEFAULT_BACKGROUND_COLOR);
break;
case PROP_FONT:
g_value_take_boxed (value, pango_font_description_from_string (DEFAULT_FONT));
break;
case PROP_PALETTE:
set_value_from_palette (value, DEFAULT_PALETTE, TERMINAL_PALETTE_SIZE);
break;
default:
g_param_value_set_default (pspec, value);
break;
}
if (notify)
{
g_object_set_property (G_OBJECT (profile), pspec->name, value);
g_value_unset (value);
}
}
static void
thunar_preferences_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ThunarPreferences *preferences = THUNAR_PREFERENCES (object);
GValue *src;
src = preferences->values + prop_id;
if (G_IS_VALUE (src))
g_value_copy (src, value);
else
g_param_value_set_default (pspec, value);
}
static gboolean
param_value_array_validate (GParamSpec *pspec,
GValue *value)
{
GParamSpecValueArray *aspec = G_PARAM_SPEC_VALUE_ARRAY (pspec);
GValueArray *value_array = value->data[0].v_pointer;
guint changed = 0;
if (!value->data[0].v_pointer && aspec->fixed_n_elements)
value->data[0].v_pointer = g_value_array_new (aspec->fixed_n_elements);
if (value->data[0].v_pointer)
{
/* ensure array size validity */
changed += value_array_ensure_size (value_array, aspec->fixed_n_elements);
/* ensure array values validity against a present element spec */
if (aspec->element_spec)
{
GParamSpec *element_spec = aspec->element_spec;
guint i;
for (i = 0; i < value_array->n_values; i++)
{
GValue *element = value_array->values + i;
/* need to fixup value type, or ensure that the array value is initialized at all */
if (!g_value_type_compatible (G_VALUE_TYPE (element), G_PARAM_SPEC_VALUE_TYPE (element_spec)))
{
if (G_VALUE_TYPE (element) != 0)
g_value_unset (element);
g_value_init (element, G_PARAM_SPEC_VALUE_TYPE (element_spec));
g_param_value_set_default (element_spec, element);
changed++;
}
/* validate array value against element_spec */
changed += g_param_value_validate (element_spec, element);
}
}
}
return changed;
}
static void
terminal_profile_init (TerminalProfile *profile)
{
TerminalProfilePrivate *priv;
GObjectClass *object_class;
GParamSpec **pspecs;
guint n_pspecs, i;
priv = profile->priv = G_TYPE_INSTANCE_GET_PRIVATE (profile, TERMINAL_TYPE_PROFILE, TerminalProfilePrivate);
priv->gsettings_notification_pspec = NULL;
priv->locked = g_new0 (gboolean, LAST_PROP);
priv->properties = g_value_array_new (LAST_PROP);
for (i = 0; i < LAST_PROP; ++i)
g_value_array_append (priv->properties, NULL);
pspecs = g_object_class_list_properties (G_OBJECT_CLASS (TERMINAL_PROFILE_GET_CLASS (profile)), &n_pspecs);
for (i = 0; i < n_pspecs; ++i)
{
GParamSpec *pspec = pspecs[i];
GValue *value;
if (pspec->owner_type != TERMINAL_TYPE_PROFILE)
continue;
g_assert (pspec->param_id < LAST_PROP);
value = g_value_array_get_nth (priv->properties, pspec->param_id);
g_value_init (value, pspec->value_type);
g_param_value_set_default (pspec, value);
}
g_free (pspecs);
/* A few properties don't have defaults via the param spec; set them explicitly */
object_class = G_OBJECT_CLASS (TERMINAL_PROFILE_GET_CLASS (profile));
terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_FOREGROUND_COLOR), FALSE);
terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_BOLD_COLOR), FALSE);
terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_BACKGROUND_COLOR), FALSE);
terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_FONT), FALSE);
terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_PALETTE), FALSE);
}
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;
}
static GtkCssValue *
gtk_css_custom_property_create_initial_value (GParamSpec *pspec)
{
GValue value = G_VALUE_INIT;
GtkCssValue *result;
g_value_init (&value, pspec->value_type);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (pspec->value_type == GTK_TYPE_THEMING_ENGINE)
g_value_set_object (&value, gtk_theming_engine_load (NULL));
else if (pspec->value_type == PANGO_TYPE_FONT_DESCRIPTION)
g_value_take_boxed (&value, pango_font_description_from_string ("Sans 10"));
else if (pspec->value_type == GDK_TYPE_RGBA)
{
GdkRGBA color;
gdk_rgba_parse (&color, "pink");
g_value_set_boxed (&value, &color);
}
else if (pspec->value_type == g_type_from_name ("GdkColor"))
{
GdkColor color;
gdk_color_parse ("pink", &color);
g_value_set_boxed (&value, &color);
}
else if (pspec->value_type == GTK_TYPE_BORDER)
{
g_value_take_boxed (&value, gtk_border_new ());
}
else
g_param_value_set_default (pspec, &value);
G_GNUC_END_IGNORE_DEPRECATIONS
result = _gtk_css_typed_value_new (&value);
g_value_unset (&value);
return result;
}
static void
thunar_preferences_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ThunarPreferences *preferences = THUNAR_PREFERENCES (object);
GValue *dst;
dst = preferences->values + prop_id;
if (G_UNLIKELY (!G_IS_VALUE (dst)))
{
g_value_init (dst, pspec->value_type);
g_param_value_set_default (pspec, dst);
}
if (g_param_values_cmp (pspec, value, dst) != 0)
{
g_value_copy (value, dst);
thunar_preferences_queue_store (preferences);
}
}
/* Invalidate style to recompute styles */
static void _xfdashboard_actor_stylable_invalidate(XfdashboardStylable *inStylable)
{
XfdashboardActor *self;
XfdashboardActorPrivate *priv;
XfdashboardActorClass *klass;
XfdashboardTheme *theme;
XfdashboardThemeCSS *themeCSS;
GHashTable *possibleStyleSet;
GParamSpec *paramSpec;
GHashTableIter hashIter;
GHashTable *themeStyleSet;
gchar *styleName;
XfdashboardThemeCSSValue *styleValue;
gboolean didChange;
#ifdef DEBUG
gboolean doDebug=FALSE;
#endif
g_return_if_fail(XFDASHBOARD_IS_ACTOR(inStylable));
self=XFDASHBOARD_ACTOR(inStylable);
priv=self->priv;
klass=XFDASHBOARD_ACTOR_GET_CLASS(self);
didChange=FALSE;
/* Only recompute style for mapped actors or if revalidation was forced */
if(!priv->forceStyleRevalidation && !clutter_actor_is_mapped(CLUTTER_ACTOR(self))) return;
/* Get theme CSS */
theme=xfdashboard_application_get_theme(NULL);
themeCSS=xfdashboard_theme_get_css(theme);
/* First get list of all stylable properties of this and parent classes.
* It is used to determine if key in theme style sets are valid.
*/
possibleStyleSet=xfdashboard_actor_get_stylable_properties_full(klass);
#ifdef DEBUG
if(doDebug)
{
gint i=0;
gchar *defaultsKey;
GValue defaultsVal=G_VALUE_INIT;
gchar *defaultsValStr;
GParamSpec *realParamSpec;
XFDASHBOARD_DEBUG(self, STYLE,
"Got param specs for %p (%s) with class '%s' and pseudo-class '%s'",
self,
G_OBJECT_TYPE_NAME(self),
priv->styleClasses,
priv->stylePseudoClasses);
g_hash_table_iter_init(&hashIter, possibleStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&defaultsKey, (gpointer*)¶mSpec))
{
realParamSpec=(GParamSpec*)g_param_spec_get_qdata(paramSpec, XFDASHBOARD_ACTOR_PARAM_SPEC_REF);
g_value_init(&defaultsVal, G_PARAM_SPEC_VALUE_TYPE(realParamSpec));
g_param_value_set_default(realParamSpec, &defaultsVal);
defaultsValStr=g_strdup_value_contents(&defaultsVal);
XFDASHBOARD_DEBUG(self, STYLE,
"%d: param spec [%s] %s=%s\n",
++i,
G_OBJECT_CLASS_NAME(klass),
defaultsKey,
defaultsValStr);
g_free(defaultsValStr);
g_value_unset(&defaultsVal);
}
XFDASHBOARD_DEBUG(self, STYLE, "End of param specs");
}
#endif
/* Get style information from theme */
themeStyleSet=xfdashboard_theme_css_get_properties(themeCSS, XFDASHBOARD_STYLABLE(self));
#ifdef DEBUG
if(doDebug)
{
gint i=0;
XFDASHBOARD_DEBUG(self, STYLE,
"Got styles from theme for %p (%s) with class '%s' and pseudo-class '%s'",
self,
G_OBJECT_TYPE_NAME(self),
priv->styleClasses,
priv->stylePseudoClasses);
g_hash_table_iter_init(&hashIter, themeStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&styleName, (gpointer*)&styleValue))
{
XFDASHBOARD_DEBUG(self, STYLE,
"%d: [%s] %s=%s\n",
++i,
styleValue->source,
(gchar*)styleName,
styleValue->string);
}
XFDASHBOARD_DEBUG(self, STYLE, "End of styles from theme");
}
#endif
/* The 'property-changed' notification will be freezed and thawed
* (fired at once) after all stylable properties of this instance are set.
*/
g_object_freeze_notify(G_OBJECT(self));
/* Iterate through style information retrieved from theme and
* set the corresponding property in object instance if key
* is valid.
*/
g_hash_table_iter_init(&hashIter, themeStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&styleName, (gpointer*)&styleValue))
{
GValue cssValue=G_VALUE_INIT;
GValue propertyValue=G_VALUE_INIT;
GParamSpec *realParamSpec;
/* Check if key is a valid object property name */
if(!g_hash_table_lookup_extended(possibleStyleSet, styleName, NULL, (gpointer*)¶mSpec)) continue;
/* Get original referenced parameter specification. It does not need
* to be referenced while converting because it is valid as this
* value is stored in hashtable.
*/
realParamSpec=(GParamSpec*)g_param_spec_get_qdata(paramSpec, XFDASHBOARD_ACTOR_PARAM_SPEC_REF);
/* Convert style value to type of object property and set value
* if conversion was successful. Otherwise do nothing.
*/
g_value_init(&cssValue, G_TYPE_STRING);
g_value_set_string(&cssValue, styleValue->string);
g_value_init(&propertyValue, G_PARAM_SPEC_VALUE_TYPE(realParamSpec));
if(g_param_value_convert(realParamSpec, &cssValue, &propertyValue, FALSE))
{
g_object_set_property(G_OBJECT(self), styleName, &propertyValue);
didChange=TRUE;
#ifdef DEBUG
if(doDebug)
{
gchar *valstr;
valstr=g_strdup_value_contents(&propertyValue);
XFDASHBOARD_DEBUG(self, STYLE,
"Setting theme value of style property [%s] %s=%s\n",
G_OBJECT_CLASS_NAME(klass),
styleName,
valstr);
g_free(valstr);
}
#endif
}
else
{
g_warning(_("Could not transform CSS string value for property '%s' to type %s of class %s"),
styleName, g_type_name(G_PARAM_SPEC_VALUE_TYPE(realParamSpec)), G_OBJECT_CLASS_NAME(klass));
}
/* Release allocated resources */
g_value_unset(&propertyValue);
g_value_unset(&cssValue);
}
/* Now remove all duplicate keys in set of properties changed we set the last
* time. The remaining keys determine the properties which were set the last
* time but not this time and should be restored to their default values.
*/
if(priv->lastThemeStyleSet)
{
/* Remove duplicate keys from set of last changed properties */
g_hash_table_foreach_remove(priv->lastThemeStyleSet, (GHRFunc)_xfdashboard_actor_hashtable_is_duplicate_key, themeStyleSet);
/* Iterate through remaining key and restore corresponding object properties
* to their default values.
*/
g_hash_table_iter_init(&hashIter, priv->lastThemeStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&styleName, (gpointer*)¶mSpec))
{
GValue propertyValue=G_VALUE_INIT;
GParamSpec *realParamSpec;
/* Check if key is a valid object property name */
if(!g_hash_table_lookup_extended(possibleStyleSet, styleName, NULL, (gpointer*)¶mSpec)) continue;
/* Get original referenced parameter specification. It does not need
* to be referenced while converting because it is valid as this
* value is stored in hashtable.
*/
realParamSpec=(GParamSpec*)g_param_spec_get_qdata(paramSpec, XFDASHBOARD_ACTOR_PARAM_SPEC_REF);
/* Initialize property value to its type and default value */
g_value_init(&propertyValue, G_PARAM_SPEC_VALUE_TYPE(realParamSpec));
g_param_value_set_default(realParamSpec, &propertyValue);
/* Set value at object property */
g_object_set_property(G_OBJECT(self), styleName, &propertyValue);
didChange=TRUE;
#ifdef DEBUG
if(doDebug)
{
gchar *valstr;
valstr=g_strdup_value_contents(&propertyValue);
XFDASHBOARD_DEBUG(self, STYLE,
"Restoring default value of style property [%s] %s=%s\n",
G_OBJECT_CLASS_NAME(klass),
styleName,
valstr);
g_free(valstr);
}
#endif
/* Release allocated resources */
g_value_unset(&propertyValue);
}
/* Release resources of set of last changed properties as we do not need
* it anymore.
*/
g_hash_table_destroy(priv->lastThemeStyleSet);
priv->lastThemeStyleSet=NULL;
}
/* Remember this set of changed properties for next time to determine properties
* which need to be restored to their default value.
*/
priv->lastThemeStyleSet=themeStyleSet;
/* Release allocated resources */
g_hash_table_destroy(possibleStyleSet);
/* Force a redraw if any change was made at this actor */
if(didChange) clutter_actor_queue_redraw(CLUTTER_ACTOR(self));
/* Reset force style revalidation flag because it's done now */
priv->forceStyleRevalidation=FALSE;
/* All stylable properties are set now. So thaw 'property-changed'
* notification now and fire all notifications at once.
*/
g_object_thaw_notify(G_OBJECT(self));
}
static void
print_element_properties_info (GstElement * element)
{
GParamSpec **property_specs;
guint num_properties, i;
gboolean readable;
gboolean first_flag;
property_specs = g_object_class_list_properties
(G_OBJECT_GET_CLASS (element), &num_properties);
n_print ("\n");
n_print ("Element Properties:\n");
for (i = 0; i < num_properties; i++) {
GValue value = { 0, };
GParamSpec *param = property_specs[i];
readable = FALSE;
g_value_init (&value, param->value_type);
n_print (" %-20s: %s\n", g_param_spec_get_name (param),
g_param_spec_get_blurb (param));
first_flag = TRUE;
n_print ("%-23.23s flags: ", "");
if (param->flags & G_PARAM_READABLE) {
g_object_get_property (G_OBJECT (element), param->name, &value);
readable = TRUE;
g_print ("%s%s", (first_flag) ? "" : ", ", _("readable"));
first_flag = FALSE;
} else {
/* if we can't read the property value, assume it's set to the default
* (which might not be entirely true for sub-classes, but that's an
* unlikely corner-case anyway) */
g_param_value_set_default (param, &value);
}
if (param->flags & G_PARAM_WRITABLE) {
g_print ("%s%s", (first_flag) ? "" : ", ", _("writable"));
first_flag = FALSE;
}
if (param->flags & G_PARAM_DEPRECATED) {
g_print ("%s%s", (first_flag) ? "" : ", ", _("deprecated"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_CONTROLLABLE) {
g_print (", %s", _("controllable"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_MUTABLE_PLAYING) {
g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state"));
} else if (param->flags & GST_PARAM_MUTABLE_PAUSED) {
g_print (", %s", _("changeable only in NULL, READY or PAUSED state"));
} else if (param->flags & GST_PARAM_MUTABLE_READY) {
g_print (", %s", _("changeable only in NULL or READY state"));
}
if (param->flags & ~KNOWN_PARAM_FLAGS) {
g_print ("%s0x%0x", (first_flag) ? "" : ", ",
param->flags & ~KNOWN_PARAM_FLAGS);
}
n_print ("\n");
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
{
const char *string_val = g_value_get_string (&value);
n_print ("%-23.23s String. ", "");
if (string_val == NULL)
g_print ("Default: null");
else
g_print ("Default: \"%s\"", string_val);
break;
}
case G_TYPE_BOOLEAN:
{
gboolean bool_val = g_value_get_boolean (&value);
n_print ("%-23.23s Boolean. ", "");
g_print ("Default: %s", bool_val ? "true" : "false");
break;
}
case G_TYPE_ULONG:
{
GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
n_print ("%-23.23s Unsigned Long. ", "");
g_print ("Range: %lu - %lu Default: %lu ",
pulong->minimum, pulong->maximum, g_value_get_ulong (&value));
GST_ERROR ("%s: property '%s' of type ulong: consider changing to "
"uint/uint64", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
break;
}
case G_TYPE_LONG:
{
GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
n_print ("%-23.23s Long. ", "");
g_print ("Range: %ld - %ld Default: %ld ",
plong->minimum, plong->maximum, g_value_get_long (&value));
GST_ERROR ("%s: property '%s' of type long: consider changing to "
"int/int64", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
break;
}
case G_TYPE_UINT:
{
GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
n_print ("%-23.23s Unsigned Integer. ", "");
g_print ("Range: %u - %u Default: %u ",
puint->minimum, puint->maximum, g_value_get_uint (&value));
break;
}
case G_TYPE_INT:
{
GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
n_print ("%-23.23s Integer. ", "");
g_print ("Range: %d - %d Default: %d ",
pint->minimum, pint->maximum, g_value_get_int (&value));
break;
}
case G_TYPE_UINT64:
{
GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
n_print ("%-23.23s Unsigned Integer64. ", "");
g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT
" Default: %" G_GUINT64_FORMAT " ",
puint64->minimum, puint64->maximum, g_value_get_uint64 (&value));
break;
}
case G_TYPE_INT64:
{
GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
n_print ("%-23.23s Integer64. ", "");
g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
" Default: %" G_GINT64_FORMAT " ",
pint64->minimum, pint64->maximum, g_value_get_int64 (&value));
break;
}
case G_TYPE_FLOAT:
{
GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
n_print ("%-23.23s Float. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pfloat->minimum, pfloat->maximum, g_value_get_float (&value));
break;
}
case G_TYPE_DOUBLE:
{
GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
n_print ("%-23.23s Double. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pdouble->minimum, pdouble->maximum, g_value_get_double (&value));
break;
}
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
GST_ERROR ("%s: property '%s' of type char: consider changing to "
"int/string", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
/* fall through */
default:
if (param->value_type == GST_TYPE_CAPS) {
const GstCaps *caps = gst_value_get_caps (&value);
if (!caps)
n_print ("%-23.23s Caps (NULL)", "");
else {
print_caps (caps, " ");
}
} else if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
guint j = 0;
gint enum_value;
const gchar *value_nick = "";
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
enum_value = g_value_get_enum (&value);
while (values[j].value_name) {
if (values[j].value == enum_value)
value_nick = values[j].value_nick;
j++;
}
n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\"", "",
g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick);
j = 0;
while (values[j].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (%d): %-16s - %s", "",
values[j].value, values[j].value_nick, values[j].value_name);
j++;
}
/* g_type_class_unref (ec); */
} else if (G_IS_PARAM_SPEC_FLAGS (param)) {
GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param);
GFlagsValue *vals;
gchar *cur;
vals = pflags->flags_class->values;
cur = flags_to_string (vals, g_value_get_flags (&value));
n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "",
g_type_name (G_VALUE_TYPE (&value)),
g_value_get_flags (&value), cur);
while (vals[0].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (0x%08x): %-16s - %s", "",
vals[0].value, vals[0].value_nick, vals[0].value_name);
++vals;
}
g_free (cur);
} else if (G_IS_PARAM_SPEC_OBJECT (param)) {
n_print ("%-23.23s Object of type \"%s\"", "",
g_type_name (param->value_type));
} else if (G_IS_PARAM_SPEC_BOXED (param)) {
n_print ("%-23.23s Boxed pointer of type \"%s\"", "",
g_type_name (param->value_type));
if (param->value_type == GST_TYPE_STRUCTURE) {
const GstStructure *s = gst_value_get_structure (&value);
if (s)
gst_structure_foreach (s, print_field,
(gpointer) " ");
}
} else if (G_IS_PARAM_SPEC_POINTER (param)) {
if (param->value_type != G_TYPE_POINTER) {
n_print ("%-23.23s Pointer of type \"%s\".", "",
g_type_name (param->value_type));
} else {
n_print ("%-23.23s Pointer.", "");
}
} else if (param->value_type == G_TYPE_VALUE_ARRAY) {
GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param);
if (pvarray->element_spec) {
n_print ("%-23.23s Array of GValues of type \"%s\"", "",
g_type_name (pvarray->element_spec->value_type));
} else {
n_print ("%-23.23s Array of GValues", "");
}
} else if (GST_IS_PARAM_SPEC_FRACTION (param)) {
GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param);
n_print ("%-23.23s Fraction. ", "");
g_print ("Range: %d/%d - %d/%d Default: %d/%d ",
pfraction->min_num, pfraction->min_den,
pfraction->max_num, pfraction->max_den,
gst_value_get_fraction_numerator (&value),
gst_value_get_fraction_denominator (&value));
} else {
n_print ("%-23.23s Unknown type %ld \"%s\"", "",
(glong) param->value_type, g_type_name (param->value_type));
}
break;
}
if (!readable)
g_print (" Write only\n");
else
g_print ("\n");
g_value_reset (&value);
}
if (num_properties == 0)
n_print (" none\n");
g_free (property_specs);
}
/* Default implementation of virtual function "invalidate" */
static void _xfdashboard_stylable_real_invalidate(XfdashboardStylable *self)
{
XfdashboardTheme *theme;
XfdashboardThemeCSS *themeCSS;
GHashTable *stylableProperties;
GHashTable *themeStyleSet;
GHashTableIter hashIter;
gchar *propertyName;
GParamSpec *propertyValueParamSpec;
XfdashboardThemeCSSValue *styleValue;
g_return_if_fail(XFDASHBOARD_IS_STYLABLE(self));
/* Get hashtable with all stylable properties and their parameter
* specification for default values.
*/
stylableProperties=xfdashboard_stylable_get_stylable_properties(self);
if(!stylableProperties) return;
/* Get theme CSS */
theme=xfdashboard_application_get_theme();
themeCSS=xfdashboard_theme_get_css(theme);
/* Get styled properties from theme CSS */
themeStyleSet=xfdashboard_theme_css_get_properties(themeCSS, self);
/* The 'property-changed' notification will be freezed and thawed
* (fired at once) after all stylable properties of this instance are set.
*/
g_object_freeze_notify(G_OBJECT(self));
/* Iterate through stylable properties and check if we got a style of
* that name from theme CSS. If we find such a style set the corresponding
* property in object otherwise set default value to override any
* previous value set by theme CSS to reset it.
*/
g_hash_table_iter_init(&hashIter, stylableProperties);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&propertyName, (gpointer*)&propertyValueParamSpec))
{
/* Check if we got a style with this name from theme CSS and
* set style's value if found ...
*/
if(g_hash_table_lookup_extended(themeStyleSet, propertyName, NULL, (gpointer*)&styleValue))
{
GValue cssValue=G_VALUE_INIT;
GValue propertyValue=G_VALUE_INIT;
/* Convert style value to type of object property and set value
* if conversion was successful. Otherwise do nothing.
*/
g_value_init(&cssValue, G_TYPE_STRING);
g_value_set_string(&cssValue, styleValue->string);
g_value_init(&propertyValue, G_PARAM_SPEC_VALUE_TYPE(propertyValueParamSpec));
if(g_param_value_convert(propertyValueParamSpec, &cssValue, &propertyValue, FALSE))
{
g_object_set_property(G_OBJECT(self), propertyName, &propertyValue);
}
else
{
g_warning(_("Could not transform CSS string value for property '%s' to type %s of class %s"),
propertyName,
g_type_name(G_PARAM_SPEC_VALUE_TYPE(propertyValueParamSpec)),
G_OBJECT_TYPE_NAME(self));
}
/* Release allocated resources */
g_value_unset(&propertyValue);
g_value_unset(&cssValue);
}
/* ... otherwise set property's default value we got from
* stylable interface of object.
*/
else
{
GValue propertyValue=G_VALUE_INIT;
/* Initialize property value to its type and default value */
g_value_init(&propertyValue, G_PARAM_SPEC_VALUE_TYPE(propertyValueParamSpec));
g_param_value_set_default(propertyValueParamSpec, &propertyValue);
/* Set value at object property */
g_object_set_property(G_OBJECT(self), propertyName, &propertyValue);
/* Release allocated resources */
g_value_unset(&propertyValue);
}
}
/* All stylable properties are set now. So thaw 'property-changed'
* notification now and fire all notifications at once.
*/
g_object_thaw_notify(G_OBJECT(self));
/* Release allocated resources */
g_hash_table_destroy(themeStyleSet);
g_hash_table_destroy(stylableProperties);
}
GParamSpec *
gimp_param_spec_duplicate (GParamSpec *pspec)
{
GParamSpec *copy = NULL;
GParamFlags flags;
g_return_val_if_fail (pspec != NULL, NULL);
flags = pspec->flags | GIMP_CONFIG_PARAM_SERIALIZE;
if (G_IS_PARAM_SPEC_STRING (pspec))
{
GParamSpecString *spec = G_PARAM_SPEC_STRING (pspec);
if (GEGL_IS_PARAM_SPEC_FILE_PATH (pspec))
{
copy = gimp_param_spec_config_path (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
GIMP_CONFIG_PATH_FILE,
spec->default_value,
flags);
}
else
{
static GQuark multiline_quark = 0;
if (! multiline_quark)
multiline_quark = g_quark_from_static_string ("multiline");
copy = g_param_spec_string (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->default_value,
flags);
if (GEGL_IS_PARAM_SPEC_MULTILINE (pspec))
{
g_param_spec_set_qdata (copy, multiline_quark,
GINT_TO_POINTER (TRUE));
}
}
}
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
{
GParamSpecBoolean *spec = G_PARAM_SPEC_BOOLEAN (pspec);
copy = g_param_spec_boolean (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->default_value,
flags);
}
else if (G_IS_PARAM_SPEC_ENUM (pspec))
{
GParamSpecEnum *spec = G_PARAM_SPEC_ENUM (pspec);
copy = g_param_spec_enum (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
G_TYPE_FROM_CLASS (spec->enum_class),
spec->default_value,
flags);
}
else if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec))
{
GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec);
GParamSpecDouble *spec = G_PARAM_SPEC_DOUBLE (pspec);
copy = gegl_param_spec_double (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
gspec->ui_minimum,
gspec->ui_maximum,
gspec->ui_gamma,
flags);
}
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
{
GParamSpecDouble *spec = G_PARAM_SPEC_DOUBLE (pspec);
copy = g_param_spec_double (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (G_IS_PARAM_SPEC_FLOAT (pspec))
{
GParamSpecFloat *spec = G_PARAM_SPEC_FLOAT (pspec);
copy = g_param_spec_float (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (GEGL_IS_PARAM_SPEC_INT (pspec))
{
GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec);
GParamSpecInt *spec = G_PARAM_SPEC_INT (pspec);
copy = gegl_param_spec_int (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
gspec->ui_minimum,
gspec->ui_maximum,
gspec->ui_gamma,
flags);
}
else if (GEGL_IS_PARAM_SPEC_SEED (pspec))
{
copy = gegl_param_spec_seed (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
pspec->flags |
GIMP_CONFIG_PARAM_SERIALIZE);
}
else if (G_IS_PARAM_SPEC_INT (pspec))
{
GParamSpecInt *spec = G_PARAM_SPEC_INT (pspec);
copy = g_param_spec_int (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (G_IS_PARAM_SPEC_UINT (pspec))
{
GParamSpecUInt *spec = G_PARAM_SPEC_UINT (pspec);
copy = g_param_spec_uint (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (GIMP_IS_PARAM_SPEC_RGB (pspec))
{
GValue value = G_VALUE_INIT;
GimpRGB color;
g_value_init (&value, GIMP_TYPE_RGB);
g_param_value_set_default (pspec, &value);
gimp_value_get_rgb (&value, &color);
g_value_unset (&value);
copy = gimp_param_spec_rgb (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
gimp_param_spec_rgb_has_alpha (pspec),
&color,
flags);
}
else if (GEGL_IS_PARAM_SPEC_COLOR (pspec))
{
GeglColor *gegl_color;
GimpRGB gimp_color;
gdouble r = 0.0;
gdouble g = 0.0;
gdouble b = 0.0;
gdouble a = 1.0;
GValue value = { 0, };
g_value_init (&value, GEGL_TYPE_COLOR);
g_param_value_set_default (pspec, &value);
gegl_color = g_value_get_object (&value);
if (gegl_color)
gegl_color_get_rgba (gegl_color, &r, &g, &b, &a);
gimp_rgba_set (&gimp_color, r, g, b, a);
g_value_unset (&value);
copy = gimp_param_spec_rgb (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
TRUE,
&gimp_color,
flags);
}
else if (G_IS_PARAM_SPEC_OBJECT (pspec) ||
G_IS_PARAM_SPEC_POINTER (pspec))
{
/* silently ignore object properties */
}
else
{
g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name);
}
if (copy)
{
GQuark quark = g_quark_from_static_string ("gegl-property-keys");
GHashTable *keys = g_param_spec_get_qdata (pspec, quark);
if (keys)
g_param_spec_set_qdata (copy, quark, g_hash_table_ref (keys));
}
return copy;
}
