static void add_reference (GString *str, GParamSpec *pspec) { const gchar *table_name; const gchar *property_name; table_name = g_param_spec_get_qdata(pspec, GOM_RESOURCE_REF_TABLE_CLASS); if (!table_name) return; property_name = g_param_spec_get_qdata(pspec, GOM_RESOURCE_REF_PROPERTY_NAME); g_assert(property_name); g_string_append_printf(str, " REFERENCES [%s]([%s]) ", table_name, property_name); }
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); }
static void resource_get_property(GObject *object, const gchar *property_name, GValue *value) { GValue real_value = { 0, }; GomResourceToBytesFunc to_bytes; GParamSpec *pspec; GBytes *bytes; pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object), property_name); g_assert(pspec); g_value_init(&real_value, pspec->value_type); g_object_get_property(object, property_name, &real_value); to_bytes = g_param_spec_get_qdata(pspec, GOM_RESOURCE_TO_BYTES_FUNC); if (!to_bytes) { *value = real_value; return; } bytes = (* to_bytes) (&real_value); g_value_init(value, G_TYPE_BYTES); g_value_take_boxed(value, bytes); g_value_unset(&real_value); }
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 gboolean is_new_in_version (GParamSpec *pspec, guint version) { /* This is a bit ugly, but this allows us to consider * an unset value to be new in version 1. Version 0 * is for "pre-GOM" SQLite usage. */ return (GPOINTER_TO_INT(g_param_spec_get_qdata(pspec, GOM_RESOURCE_NEW_IN_VERSION)) + 1) == version; }
/** * uca_camera_is_writable_during_acquisition: * @camera: A #UcaCamera object * @prop_name: Name of property * * Check if @prop_name can be written at run-time. This is %FALSE if the * property is read-only, if uca_camera_set_writable() has not been called or * uca_camera_set_writable() was called with %FALSE. * * Returns: %TRUE if the property can be written at acquisition time. * Since: 1.6 */ gboolean uca_camera_is_writable_during_acquisition (UcaCamera *camera, const gchar *prop_name) { GParamSpec *pspec; pspec = get_param_spec_by_name (camera, prop_name); return (pspec->flags & G_PARAM_WRITABLE) && g_param_spec_get_qdata (pspec, UCA_WRITABLE_QUARK); }
/** * uca_camera_pspec_set_writable: (skip) * @pspec: A #GParamSpec * @writable: %TRUE if property can be written during acquisition * * Sets a flag that defines if the property defined by @pspec can be written * during an acquisition. This can be used during UcaCamera class * initialization. * * Since: 2.1 */ void uca_camera_pspec_set_writable (GParamSpec *pspec, gboolean writable) { if (pspec != NULL) { if (g_param_spec_get_qdata (pspec, UCA_WRITABLE_QUARK) != NULL) g_warning ("::%s is already fixed", pspec->name); else g_param_spec_set_qdata (pspec, UCA_WRITABLE_QUARK, GINT_TO_POINTER (writable)); } }
static void add_notnull (GString *str, GParamSpec *pspec) { gboolean notnull; notnull = GPOINTER_TO_UINT(g_param_spec_get_qdata(pspec, GOM_RESOURCE_NOTNULL)); if (!notnull) return; g_string_append_printf(str, " NOT NULL "); }
static void add_unique (GString *str, GParamSpec *pspec) { gboolean unique; unique = GPOINTER_TO_UINT(g_param_spec_get_qdata(pspec, GOM_RESOURCE_UNIQUE)); if (!unique) return; g_string_append_printf(str, " UNIQUE "); }
static void uca_camera_set_property_unit (GParamSpec *pspec, UcaUnit unit) { UcaUnit old_unit; old_unit = (UcaUnit) GPOINTER_TO_INT (g_param_spec_get_qdata (pspec, UCA_UNIT_QUARK)); if (old_unit != unit && old_unit != UCA_UNIT_NA) g_warning ("::%s already has a different unit", pspec->name); else g_param_spec_set_qdata (pspec, UCA_UNIT_QUARK, GINT_TO_POINTER (unit)); }
static void gst_fameenc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstFameEnc *fameenc; g_return_if_fail (GST_IS_FAMEENC (object)); fameenc = GST_FAMEENC (object); switch (prop_id) { case ARG_BITRATE: g_value_set_int (value, fameenc->fp.bitrate); break; case ARG_QUALITY: g_value_set_int (value, fameenc->fp.quality); break; case ARG_PATTERN: g_value_set_string (value, fameenc->pattern); break; case ARG_FAME_VERBOSE: g_value_set_boolean (value, fameenc->verbose); break; case ARG_BUFFER_SIZE: g_value_set_int (value, fameenc->buffer_size); break; case ARG_FRAMES_PER_SEQUENCE: g_value_set_int (value, fameenc->fp.frames_per_sequence); break; default: if (prop_id >= ARG_FAME_PROPS_START) { gchar *name; gint index = 0; GEnumValue *values; fame_object_t *f_object; values = G_ENUM_CLASS (g_type_class_ref (pspec->value_type))->values; name = (gchar *) g_param_spec_get_qdata (pspec, fame_object_name); f_object = fame_get_object (fameenc->fc, name); while (values[index].value_name) { if (!strcmp (values[index].value_nick, f_object->name)) { g_value_set_enum (value, index); return; } index++; } } G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
VALUE rbgobj_get_ruby_object_from_param_spec(GParamSpec* pspec, gboolean alloc) { gpointer data = g_param_spec_get_qdata(pspec, qparamspec); if (data) return (VALUE)data; else if (alloc) { VALUE result = pspec_s_allocate(GTYPE2CLASS(G_PARAM_SPEC_TYPE(pspec))); rbgobj_param_spec_initialize(result, pspec); return result; } else return Qnil; }
static void gst_fameenc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstFameEnc *fameenc; g_return_if_fail (GST_IS_FAMEENC (object)); fameenc = GST_FAMEENC (object); if (fameenc->initialized) { GST_DEBUG ("error: fameenc encoder already initialized, cannot set properties !"); return; } switch (prop_id) { case ARG_BITRATE: fameenc->fp.bitrate = g_value_get_int (value); break; case ARG_QUALITY: fameenc->fp.quality = CLAMP (g_value_get_int (value), 0, 100); break; case ARG_PATTERN: g_free (fameenc->pattern); fameenc->pattern = g_strdup (g_value_get_string (value)); break; case ARG_FAME_VERBOSE: fameenc->verbose = g_value_get_boolean (value); break; case ARG_BUFFER_SIZE: fameenc->buffer_size = g_value_get_int (value); break; case ARG_FRAMES_PER_SEQUENCE: fameenc->fp.frames_per_sequence = g_value_get_int (value); break; default: if (prop_id >= ARG_FAME_PROPS_START) { gchar *name; gint index = g_value_get_enum (value); GEnumValue *values; values = G_ENUM_CLASS (g_type_class_ref (pspec->value_type))->values; name = (gchar *) g_param_spec_get_qdata (pspec, fame_object_name); fame_register (fameenc->fc, name, fame_get_object (fameenc->fc, values[index].value_name)); } else G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static inline void tidy_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); }
/** * uca_camera_get_unit: * @camera: A #UcaCamera object * @prop_name: Name of a property * * Returns the unit associated with @prop_name of @camera. * * Returns: A #UcaUnit value associated with @prop_name. If there is none, the * value will be #UCA_UNIT_NA. * Since: 1.1 */ UcaUnit uca_camera_get_unit (UcaCamera *camera, const gchar *prop_name) { GParamSpec *pspec; gpointer data; pspec = get_param_spec_by_name (camera, prop_name); if (pspec == NULL) return UCA_UNIT_NA; data = g_param_spec_get_qdata (pspec, UCA_UNIT_QUARK); return data == NULL ? UCA_UNIT_NA : GPOINTER_TO_INT (data); }
static GVariant * serialize_pspec(GvsSerializer *self, GParamSpec *pspec, const GValue *value) { GvsPropertySerializeFunc func = NULL; GVariant *variant = NULL; GType type = pspec->value_type; /* Try to find the right serialization function */ func = g_param_spec_get_qdata(pspec, gvs_property_serialize_func_quark()); if (func == NULL) { if (G_TYPE_IS_FUNDAMENTAL(type)) { func = serialize_fundamental; } else if (G_TYPE_IS_ENUM(type)) { func = serialize_enum; } else if (G_TYPE_IS_FLAGS(type)) { func = serialize_flags; } else if (G_TYPE_IS_OBJECT(type) || G_TYPE_IS_INTERFACE (type)) { func = serialize_object_property; } else if (g_type_is_a(type, G_TYPE_BOXED)) { func = serialize_boxed_property; } } if (func) { variant = func(self, value, NULL); } else { g_warning("Could not serialize property %s of type %s\n" "Use gvs_register_property_serialize_func() in your class_init function\n", pspec->name, g_type_name(pspec->value_type)); } return variant; }
static void gst_xvidenc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstXvidEnc *xvidenc; guint offset; xvidenc = GST_XVIDENC (object); if (prop_id > xvidenc_prop_count) { G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); return; } /* our param specs should have such qdata */ offset = GPOINTER_TO_UINT (g_param_spec_get_qdata (pspec, xvidenc_pspec_quark)); if (offset == 0) return; switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) { case G_TYPE_BOOLEAN: g_value_set_boolean (value, G_STRUCT_MEMBER (gboolean, xvidenc, offset)); break; case G_TYPE_INT: g_value_set_int (value, G_STRUCT_MEMBER (gint, xvidenc, offset)); break; case G_TYPE_STRING: g_value_take_string (value, g_strdup (G_STRUCT_MEMBER (gchar *, xvidenc, offset))); break; default: /* must be enum, given the check above */ if (G_IS_PARAM_SPEC_ENUM (pspec)) { g_value_set_enum (value, G_STRUCT_MEMBER (gint, xvidenc, offset)); } else if (G_IS_PARAM_SPEC_FLAGS (pspec)) { g_value_set_flags (value, G_STRUCT_MEMBER (guint, xvidenc, offset)); } else { /* oops, bit lazy we don't cover this case yet */ g_critical ("%s does not yet support type %s", GST_FUNCTION, g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec))); } break; } }
static gboolean is_mapped (GParamSpec *pspec) { gboolean ret; ret = (pspec->owner_type != GOM_TYPE_RESOURCE); if (!ret) return FALSE; ret = (sql_type_for_column(pspec) != NULL); if (!ret) { g_debug("Property %s not mapped because type is unsupported (%s)", pspec->name, g_type_name(pspec->value_type)); return FALSE; } ret = !GPOINTER_TO_INT(g_param_spec_get_qdata(pspec, GOM_RESOURCE_NOT_MAPPED)); return ret; }
static void terminal_profile_notify (GObject *object, GParamSpec *pspec) { TerminalProfilePrivate *priv = TERMINAL_PROFILE (object)->priv; void (* notify) (GObject *, GParamSpec *) = G_OBJECT_CLASS (terminal_profile_parent_class)->notify; _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Property notification for prop %s\n", pspec->name); if (notify) notify (object, pspec); if (pspec->owner_type == TERMINAL_TYPE_PROFILE && (pspec->flags & G_PARAM_WRITABLE) && g_param_spec_get_qdata (pspec, gsettings_key_quark) != NULL && pspec != priv->gsettings_notification_pspec) terminal_profile_schedule_save (TERMINAL_PROFILE (object), pspec); }
static void gst_xvidenc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstXvidEnc *xvidenc; guint offset; xvidenc = GST_XVIDENC (object); if (prop_id > xvidenc_prop_count) { G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); return; } /* our param specs should have such qdata */ offset = GPOINTER_TO_UINT (g_param_spec_get_qdata (pspec, xvidenc_pspec_quark)); if (offset == 0) return; switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) { case G_TYPE_BOOLEAN: G_STRUCT_MEMBER (gboolean, xvidenc, offset) = g_value_get_boolean (value); break; case G_TYPE_INT: G_STRUCT_MEMBER (gint, xvidenc, offset) = g_value_get_int (value); break; case G_TYPE_STRING: g_free (G_STRUCT_MEMBER (gchar *, xvidenc, offset)); G_STRUCT_MEMBER (gchar *, xvidenc, offset) = g_value_dup_string (value); break; default: /* must be enum, given the check above */ if (G_IS_PARAM_SPEC_ENUM (pspec)) { G_STRUCT_MEMBER (gint, xvidenc, offset) = g_value_get_enum (value); } else { G_STRUCT_MEMBER (guint, xvidenc, offset) = g_value_get_flags (value); } break; } }
// FIXME: use rb_protect static void set_prop_func(GObject* object, guint property_id, const GValue* value, GParamSpec* pspec) { ID ruby_setter = (ID)g_param_spec_get_qdata(pspec, q_ruby_setter); if (!ruby_setter) { gchar* name = g_strconcat(g_param_spec_get_name(pspec), "=", NULL); gchar* p; for (p = name; *p; p++) { if (*p == '-') *p = '_'; } ruby_setter = rb_intern(name); g_param_spec_set_qdata(pspec, q_ruby_setter, (gpointer)ruby_setter); g_free(name); } rb_funcall(GOBJ2RVAL(object), ruby_setter, 1, GVAL2RVAL(value)); }
static const char * sql_type_for_column (GParamSpec *pspec) { GType parent_type; switch (pspec->value_type) { case G_TYPE_CHAR: case G_TYPE_INT: case G_TYPE_INT64: case G_TYPE_LONG: case G_TYPE_UCHAR: case G_TYPE_UINT: case G_TYPE_UINT64: case G_TYPE_ULONG: case G_TYPE_BOOLEAN: return "INTEGER"; case G_TYPE_STRING: return "TEXT"; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: return "FLOAT"; default: if (pspec->value_type == G_TYPE_STRV || pspec->value_type == G_TYPE_DATE_TIME) return "BLOB"; parent_type = g_type_parent(pspec->value_type); if (parent_type == G_TYPE_ENUM || parent_type == G_TYPE_FLAGS) return "INTEGER"; if (g_param_spec_get_qdata(pspec, GOM_RESOURCE_FROM_BYTES_FUNC) != NULL) return "BLOB"; g_warning("Ignoring column %s of invalid type %s\n", pspec->name, g_type_name(pspec->value_type)); return NULL; } }
// FIXME: use rb_protect static void get_prop_func(GObject* object, guint property_id, GValue* value, GParamSpec* pspec) { ID ruby_getter = (ID)g_param_spec_get_qdata(pspec, q_ruby_getter); if (!ruby_getter) { gchar* name = g_strdup(g_param_spec_get_name(pspec)); gchar* p; for (p = name; *p; p++) { if (*p == '-') *p = '_'; } ruby_getter = rb_intern(name); g_param_spec_set_qdata(pspec, q_ruby_getter, (gpointer)ruby_getter); g_free(name); } { VALUE ret = rb_funcall(GOBJ2RVAL(object), ruby_getter, 0); rbgobj_rvalue_to_gvalue(ret, value); } }
static void terminal_profile_gsettings_changeset_add (TerminalProfile *profile, GSettings *changeset, GParamSpec *pspec) { TerminalProfilePrivate *priv = profile->priv; char *key; const GValue *value; /* FIXME: do this? */ #if 0 if (priv->locked[pspec->param_id]) return; if (!g_settings_is_writable (priv->settings, gsettings_key, NULL)) return; #endif key = g_param_spec_get_qdata (pspec, gsettings_key_quark); if (!key) return; value = g_value_array_get_nth (priv->properties, pspec->param_id); _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Adding pspec %s with value %s to the GSettings changeset\n", pspec->name, g_strdup_value_contents (value)); if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) g_settings_set_boolean (changeset, key, g_value_get_boolean (value)); else if (G_IS_PARAM_SPEC_STRING (pspec)) { const char *str; str = g_value_get_string (value); g_settings_set_string (changeset, key, str ? str : ""); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { const GEnumValue *eval; eval = g_enum_get_value (G_PARAM_SPEC_ENUM (pspec)->enum_class, g_value_get_enum (value)); g_settings_set_enum (changeset, key, eval->value); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR) { GdkColor *color; char str[16]; color = g_value_get_boxed (value); if (!color) goto cleanup; g_snprintf (str, sizeof (str), "#%04X%04X%04X", color->red, color->green, color->blue); g_settings_set_string (changeset, key, str); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION) { PangoFontDescription *font_desc; char *font; font_desc = g_value_get_boxed (value); if (!font_desc) goto cleanup; font = pango_font_description_to_string (font_desc); g_settings_set_string (changeset, key, font); g_free (font); } else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) g_settings_set_double (changeset, key, g_value_get_double (value)); else if (G_IS_PARAM_SPEC_INT (pspec)) g_settings_set_int (changeset, key, g_value_get_int (value)); else if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) && G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR) { GValueArray *array; GString *string; guint n_colors, i; /* We need to do this ourselves, because the gtk_color_selection_palette_to_string * does not carry all the bytes, and xterm's palette is messed up... */ array = g_value_get_boxed (value); if (!array) goto cleanup; n_colors = array->n_values; string = g_string_sized_new (n_colors * (1 /* # */ + 3 * 4) + n_colors /* : separators and terminating \0 */); for (i = 0; i < n_colors; ++i) { GdkColor *color; if (i > 0) g_string_append_c (string, ':'); color = g_value_get_boxed (g_value_array_get_nth (array, i)); if (!color) continue; g_string_append_printf (string, "#%04X%04X%04X", color->red, color->green, color->blue); } g_settings_set_string (changeset, key, string->str); g_string_free (string, TRUE); } else g_printerr ("Unhandled value type %s of pspec %s\n", g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)), pspec->name); cleanup: return; }
/* 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)); }
GtkWidget * gimp_prop_table_new (GObject *config, GType owner_type, GimpContext *context, GimpCreatePickerFunc create_picker_func, gpointer picker_creator) { GtkWidget *table; GtkSizeGroup *size_group; GParamSpec **param_specs; guint n_param_specs; gint i; gint row = 0; GParamSpec *last_pspec = NULL; GtkAdjustment *last_x_adj = NULL; gint last_x_row = 0; g_return_val_if_fail (G_IS_OBJECT (config), NULL); g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL); param_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (config), &n_param_specs); size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); table = gtk_table_new (3, 1, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 2); for (i = 0; i < n_param_specs; i++) { GParamSpec *pspec = param_specs[i]; GtkWidget *widget = NULL; const gchar *label = NULL; /* ignore properties of parent classes of owner_type */ if (! g_type_is_a (pspec->owner_type, owner_type)) continue; if (G_IS_PARAM_SPEC_STRING (pspec)) { static GQuark multiline_quark = 0; if (! multiline_quark) multiline_quark = g_quark_from_static_string ("multiline"); if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec)) { widget = gimp_prop_file_chooser_button_new (config, pspec->name, g_param_spec_get_nick (pspec), GTK_FILE_CHOOSER_ACTION_OPEN); } else if (g_param_spec_get_qdata (pspec, multiline_quark)) { GtkTextBuffer *buffer; GtkWidget *view; buffer = gimp_prop_text_buffer_new (config, pspec->name, -1); view = gtk_text_view_new_with_buffer (buffer); widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (widget), view); gtk_widget_show (view); } else { widget = gimp_prop_entry_new (config, pspec->name, -1); } label = g_param_spec_get_nick (pspec); } else if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) { widget = gimp_prop_check_button_new (config, pspec->name, g_param_spec_get_nick (pspec)); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { widget = gimp_prop_enum_combo_box_new (config, pspec->name, 0, 0); gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (widget), g_param_spec_get_nick (pspec)); } else if (GEGL_IS_PARAM_SPEC_SEED (pspec)) { GtkAdjustment *adj; GtkWidget *scale; GtkWidget *button; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); scale = gimp_prop_spin_scale_new (config, pspec->name, g_param_spec_get_nick (pspec), 1.0, 10.0, 0); gtk_box_pack_start (GTK_BOX (widget), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gtk_button_new_with_label (_("New Seed")); gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0); gtk_widget_show (button); adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (scale)); g_signal_connect (button, "clicked", G_CALLBACK (gimp_prop_table_new_seed_clicked), adj); } else if (G_IS_PARAM_SPEC_INT (pspec) || G_IS_PARAM_SPEC_UINT (pspec) || G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec)) { GtkAdjustment *adj; gdouble value; gdouble lower; gdouble upper; gdouble step = 1.0; gdouble page = 10.0; gint digits = (G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec)) ? 2 : 0; if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec)) { GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec); lower = gspec->ui_minimum; upper = gspec->ui_maximum; } else if (GEGL_IS_PARAM_SPEC_INT (pspec)) { GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec); lower = gspec->ui_minimum; upper = gspec->ui_maximum; } else { _gimp_prop_widgets_get_numeric_values (config, pspec, &value, &lower, &upper, G_STRFUNC); } if ((upper - lower < 10.0) && (G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec))) { step = 0.1; page = 1.0; digits = 3; } widget = gimp_prop_spin_scale_new (config, pspec->name, g_param_spec_get_nick (pspec), step, page, digits); adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); if (g_str_has_suffix (pspec->name, "x") || g_str_has_suffix (pspec->name, "width")) { last_pspec = pspec; last_x_adj = adj; last_x_row = row; } else if ((g_str_has_suffix (pspec->name, "y") || g_str_has_suffix (pspec->name, "height")) && last_pspec != NULL && last_x_adj != NULL && last_x_row == row - 1) { GtkWidget *chain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gtk_table_attach (GTK_TABLE (table), chain, 3, 4, last_x_row, row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (chain); if (gtk_adjustment_get_value (last_x_adj) == gtk_adjustment_get_value (adj)) { GBinding *binding; gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain), TRUE); binding = g_object_bind_property (last_x_adj, "value", adj, "value", G_BINDING_BIDIRECTIONAL); g_object_set_data (G_OBJECT (chain), "binding", binding); } g_signal_connect (chain, "toggled", G_CALLBACK (gimp_prop_table_chain_toggled), last_x_adj); g_object_set_data (G_OBJECT (last_x_adj), "y-adjustment", adj); if (create_picker_func) { GtkWidget *button; gchar *pspec_name; pspec_name = g_strconcat (last_pspec->name, ":", pspec->name, NULL); button = create_picker_func (picker_creator, pspec_name, GIMP_STOCK_CURSOR, _("Pick coordinates from the image")); gtk_table_attach (GTK_TABLE (table), button, 4, 5, last_x_row, row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (button); g_object_weak_ref (G_OBJECT (button), (GWeakNotify) g_free, pspec_name); } } } else if (GIMP_IS_PARAM_SPEC_RGB (pspec)) { GtkWidget *button; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); button = gimp_prop_color_button_new (config, pspec->name, g_param_spec_get_nick (pspec), 128, 24, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE); gimp_color_panel_set_context (GIMP_COLOR_PANEL (button), context); gtk_box_pack_start (GTK_BOX (widget), button, TRUE, TRUE, 0); gtk_widget_show (button); if (create_picker_func) { button = create_picker_func (picker_creator, pspec->name, GIMP_STOCK_COLOR_PICKER_GRAY, _("Pick color from the image")); gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0); gtk_widget_show (button); } label = g_param_spec_get_nick (pspec); } else { g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC, g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name); } if (widget) { if (label) { gimp_table_attach_aligned (GTK_TABLE (table), 0, row, label, 0.0, 0.5, widget, 2, FALSE); } else { gtk_table_attach_defaults (GTK_TABLE (table), widget, 0, 3, row, row + 1); gtk_widget_show (widget); } row++; } } g_object_unref (size_group); g_free (param_specs); return table; }
GtkWidget * gimp_prop_widget_new_from_pspec (GObject *config, GParamSpec *pspec, GimpContext *context, GimpCreatePickerFunc create_picker_func, gpointer picker_creator, const gchar **label) { GtkWidget *widget = NULL; g_return_val_if_fail (G_IS_OBJECT (config), NULL); g_return_val_if_fail (pspec != NULL, NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (label != NULL, NULL); *label = NULL; if (GEGL_IS_PARAM_SPEC_SEED (pspec)) { GtkAdjustment *adj; GtkWidget *spin; GtkWidget *button; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); spin = gimp_prop_spin_button_new (config, pspec->name, 1.0, 10.0, 0); gtk_box_pack_start (GTK_BOX (widget), spin, TRUE, TRUE, 0); gtk_widget_show (spin); button = gtk_button_new_with_label (_("New Seed")); gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0); gtk_widget_show (button); adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin)); g_signal_connect (button, "clicked", G_CALLBACK (gimp_prop_widget_new_seed_clicked), adj); *label = g_param_spec_get_nick (pspec); } else if (G_IS_PARAM_SPEC_INT (pspec) || G_IS_PARAM_SPEC_UINT (pspec) || G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec)) { gdouble lower; gdouble upper; gdouble step; gdouble page; gint digits; if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec)) { GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec); lower = gspec->ui_minimum; upper = gspec->ui_maximum; step = gspec->ui_step_small; page = gspec->ui_step_big; digits = gspec->ui_digits; } else if (GEGL_IS_PARAM_SPEC_INT (pspec)) { GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec); lower = gspec->ui_minimum; upper = gspec->ui_maximum; step = gspec->ui_step_small; page = gspec->ui_step_big; digits = 0; } else { gdouble value; _gimp_prop_widgets_get_numeric_values (config, pspec, &value, &lower, &upper, G_STRFUNC); if ((upper - lower <= 1.0) && (G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec))) { step = 0.01; page = 0.1; digits = 4; } else if ((upper - lower <= 10.0) && (G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec))) { step = 0.1; page = 1.0; digits = 3; } else { step = 1.0; page = 10.0; digits = (G_IS_PARAM_SPEC_FLOAT (pspec) || G_IS_PARAM_SPEC_DOUBLE (pspec)) ? 2 : 0; } } widget = gimp_prop_spin_scale_new (config, pspec->name, NULL, step, page, digits); if (HAS_KEY (pspec, "unit", "degree") && (upper - lower) == 360.0) { GtkWidget *hbox; GtkWidget *dial; gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), TRUE); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_widget_show (widget); dial = gimp_prop_angle_dial_new (config, pspec->name); gtk_box_pack_start (GTK_BOX (hbox), dial, FALSE, FALSE, 0); gtk_widget_show (dial); widget = hbox; } else if (HAS_KEY (pspec, "unit", "kelvin")) { GtkWidget *hbox; GtkWidget *button; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_widget_show (widget); button = gimp_prop_kelvin_presets_new (config, pspec->name); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); widget = hbox; } } else if (G_IS_PARAM_SPEC_STRING (pspec)) { static GQuark multiline_quark = 0; if (! multiline_quark) multiline_quark = g_quark_from_static_string ("multiline"); if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec)) { widget = gimp_prop_file_chooser_button_new (config, pspec->name, g_param_spec_get_nick (pspec), GTK_FILE_CHOOSER_ACTION_OPEN); } else if (g_param_spec_get_qdata (pspec, multiline_quark)) { GtkTextBuffer *buffer; GtkWidget *view; buffer = gimp_prop_text_buffer_new (config, pspec->name, -1); view = gtk_text_view_new_with_buffer (buffer); g_object_unref (buffer); widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (widget), view); gtk_widget_show (view); } else { widget = gimp_prop_entry_new (config, pspec->name, -1); } *label = g_param_spec_get_nick (pspec); } else if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) { widget = gimp_prop_check_button_new (config, pspec->name, g_param_spec_get_nick (pspec)); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { widget = gimp_prop_enum_combo_box_new (config, pspec->name, 0, 0); gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (widget), g_param_spec_get_nick (pspec)); } else if (GIMP_IS_PARAM_SPEC_RGB (pspec)) { GtkWidget *button; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); button = gimp_prop_color_button_new (config, pspec->name, g_param_spec_get_nick (pspec), 128, 24, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE); gimp_color_panel_set_context (GIMP_COLOR_PANEL (button), context); gtk_box_pack_start (GTK_BOX (widget), button, TRUE, TRUE, 0); gtk_widget_show (button); if (create_picker_func) { button = create_picker_func (picker_creator, pspec->name, GIMP_STOCK_COLOR_PICKER_GRAY, _("Pick color from the image")); gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0); gtk_widget_show (button); } *label = g_param_spec_get_nick (pspec); } else { g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC, g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name); } return widget; }
static gboolean is_child_property (GParamSpec *pspec) { return g_param_spec_get_qdata (pspec, g_quark_from_string ("is-child-prop")) != NULL; }
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; }
static GObject * terminal_profile_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; TerminalProfile *profile; TerminalProfilePrivate *priv; const char *name; GParamSpec **pspecs; guint n_pspecs, i; object = G_OBJECT_CLASS (terminal_profile_parent_class)->constructor (type, n_construct_properties, construct_params); profile = TERMINAL_PROFILE (object); priv = profile->priv; name = g_value_get_string (g_value_array_get_nth (priv->properties, PROP_NAME)); g_assert (name != NULL); priv->settings = g_settings_new_with_path (CONF_PROFILE_SCHEMA, g_strconcat (CONF_PROFILE_PREFIX, name, "/", NULL)); g_assert (priv->settings != NULL); g_signal_connect (priv->settings, g_strconcat("changed::", priv->profile_dir, "/", NULL), G_CALLBACK(terminal_profile_gsettings_notify_cb), profile); /* Now load those properties from GSettings that were not set as construction params */ 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]; guint j; gboolean is_construct = FALSE; char *key; if (pspec->owner_type != TERMINAL_TYPE_PROFILE) continue; if ((pspec->flags & G_PARAM_WRITABLE) == 0 || (pspec->flags & G_PARAM_CONSTRUCT_ONLY) != 0) continue; for (j = 0; j < n_construct_properties; ++j) if (pspec == construct_params[j].pspec) { is_construct = TRUE; break; } if (is_construct) continue; key = g_param_spec_get_qdata (pspec, gsettings_key_quark); if (!key) continue; terminal_profile_gsettings_notify_cb (priv->settings, key, profile); } g_free (pspecs); return object; }