X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gobject%2Fgparam.c;h=e9b12926dfd0e99ded867481f31f7350c8a9a71f;hb=5602b7e275ef5fb76cf7847f35b120dce3111705;hp=db0568d7c168dd137682132dbdd9ee196aa554f1;hpb=3f4617caabf1568d26b09dbd47a2aaaf05c4f44e;p=platform%2Fupstream%2Fglib.git diff --git a/gobject/gparam.c b/gobject/gparam.c index db0568d..e9b1292 100644 --- a/gobject/gparam.c +++ b/gobject/gparam.c @@ -21,15 +21,38 @@ * MT safe */ -#include "gparam.h" +#include "config.h" +#include -#include "gvaluecollector.h" -#include +#include "gparam.h" +#include "gparamspecs.h" +#include "gvaluecollector.h" +#include "gobjectalias.h" +/** + * SECTION:gparamspec + * @Short_description: Metadata for parameter specifications + * @See_also:g_object_class_install_property(), g_object_set(), g_object_get(), + * g_object_set_property(), g_object_get_property(), g_value_register_transform_func() + * @Title: GParamSpec + * + * #GParamSpec is an object structure that encapsulates the metadata + * required to specify parameters, such as e.g. #GObject properties. + * + * + * Parameter names need to start with a letter (a-z or A-Z). Subsequent + * characters can be letters, numbers or a '-'. + * All other characters are replaced by a '-' during construction. + * The result of this replacement is called the canonical name of the + * parameter. + * + */ + /* --- defines --- */ +#define PARAM_FLOATING_FLAG 0x2 #define G_PARAM_USER_MASK (~0 << G_PARAM_USER_SHIFT) #define PSPEC_APPLIES_TO_VALUE(pspec, value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_PARAM_SPEC_VALUE_TYPE (pspec))) #define G_SLOCK(mutex) g_static_mutex_lock (mutex) @@ -61,14 +84,9 @@ static gchar* value_param_lcopy_value (const GValue *value, guint collect_flags); -/* --- variables --- */ -static GQuark quark_floating = 0; -G_LOCK_DEFINE_STATIC (pspec_ref_count); - - /* --- functions --- */ void -g_param_type_init (void) /* sync with gtype.c */ +g_param_type_init (void) { static const GTypeFundamentalInfo finfo = { (G_TYPE_FLAG_CLASSED | @@ -103,7 +121,7 @@ g_param_type_init (void) /* sync with gtype.c */ }; GType type; - type = g_type_register_fundamental (G_TYPE_PARAM, "GParam", ¶m_spec_info, &finfo, G_TYPE_FLAG_ABSTRACT); + type = g_type_register_fundamental (G_TYPE_PARAM, g_intern_static_string ("GParam"), ¶m_spec_info, &finfo, G_TYPE_FLAG_ABSTRACT); g_assert (type == G_TYPE_PARAM); g_value_register_transform_func (G_TYPE_PARAM, G_TYPE_PARAM, value_param_transform_value); } @@ -122,8 +140,6 @@ static void g_param_spec_class_init (GParamSpecClass *class, gpointer class_data) { - quark_floating = g_quark_from_static_string ("GParamSpec-floating"); - class->value_type = G_TYPE_NONE; class->finalize = g_param_spec_finalize; class->value_set_default = NULL; @@ -142,97 +158,125 @@ g_param_spec_init (GParamSpec *pspec, pspec->value_type = class->value_type; pspec->owner_type = 0; pspec->qdata = NULL; + g_datalist_init (&pspec->qdata); + g_datalist_set_flags (&pspec->qdata, PARAM_FLOATING_FLAG); pspec->ref_count = 1; pspec->param_id = 0; - g_datalist_id_set_data (&pspec->qdata, quark_floating, GUINT_TO_POINTER (TRUE)); } static void g_param_spec_finalize (GParamSpec *pspec) { g_datalist_clear (&pspec->qdata); + + if (!(pspec->flags & G_PARAM_STATIC_NAME)) + g_free (pspec->name); - g_free (pspec->name); - g_free (pspec->_nick); - g_free (pspec->_blurb); + if (!(pspec->flags & G_PARAM_STATIC_NICK)) + g_free (pspec->_nick); + + if (!(pspec->flags & G_PARAM_STATIC_BLURB)) + g_free (pspec->_blurb); g_type_free_instance ((GTypeInstance*) pspec); } +/** + * g_param_spec_ref: + * @pspec: a valid #GParamSpec + * + * Increments the reference count of @pspec. + * + * Returns: the #GParamSpec that was passed into this function + */ GParamSpec* g_param_spec_ref (GParamSpec *pspec) { g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL); + g_return_val_if_fail (pspec->ref_count > 0, NULL); + + g_atomic_int_inc (&pspec->ref_count); - G_LOCK (pspec_ref_count); - if (pspec->ref_count > 0) - { - pspec->ref_count += 1; - G_UNLOCK (pspec_ref_count); - } - else - { - G_UNLOCK (pspec_ref_count); - g_return_val_if_fail (pspec->ref_count > 0, NULL); - } - return pspec; } +/** + * g_param_spec_unref: + * @pspec: a valid #GParamSpec + * + * Decrements the reference count of a @pspec. + */ void g_param_spec_unref (GParamSpec *pspec) { + gboolean is_zero; + g_return_if_fail (G_IS_PARAM_SPEC (pspec)); + g_return_if_fail (pspec->ref_count > 0); - G_LOCK (pspec_ref_count); - if (pspec->ref_count > 0) - { - gboolean need_finalize; - - /* sync with _sink */ - pspec->ref_count -= 1; - need_finalize = pspec->ref_count == 0; - G_UNLOCK (pspec_ref_count); - if (need_finalize) - G_PARAM_SPEC_GET_CLASS (pspec)->finalize (pspec); - } - else + is_zero = g_atomic_int_dec_and_test (&pspec->ref_count); + + if (G_UNLIKELY (is_zero)) { - G_UNLOCK (pspec_ref_count); - g_return_if_fail (pspec->ref_count > 0); + G_PARAM_SPEC_GET_CLASS (pspec)->finalize (pspec); } } +/** + * g_param_spec_sink: + * @pspec: a valid #GParamSpec + * + * The initial reference count of a newly created #GParamSpec is 1, even + * though no one has explicitly called g_param_spec_ref() on it yet. So the + * initial reference count is flagged as "floating", until someone calls + * g_param_spec_ref (pspec); g_param_spec_sink (pspec); + * in sequence on it, taking over the initial reference count (thus + * ending up with a @pspec that has a reference count of 1 still, but is + * not flagged "floating" anymore). + */ void g_param_spec_sink (GParamSpec *pspec) { + gpointer oldvalue; g_return_if_fail (G_IS_PARAM_SPEC (pspec)); + g_return_if_fail (pspec->ref_count > 0); + + do + oldvalue = g_atomic_pointer_get (&pspec->qdata); + while (!g_atomic_pointer_compare_and_exchange ((void**) &pspec->qdata, oldvalue, + (gpointer) ((gsize) oldvalue & ~(gsize) PARAM_FLOATING_FLAG))); + if ((gsize) oldvalue & PARAM_FLOATING_FLAG) + g_param_spec_unref (pspec); +} - G_LOCK (pspec_ref_count); - if (pspec->ref_count > 0) - { - if (g_datalist_id_remove_no_notify (&pspec->qdata, quark_floating)) - { - /* sync with _unref */ - if (pspec->ref_count > 1) - pspec->ref_count -= 1; - else - { - G_UNLOCK (pspec_ref_count); - g_param_spec_unref (pspec); +/** + * g_param_spec_ref_sink: + * @pspec: a valid #GParamSpec + * + * Convenience function to ref and sink a #GParamSpec. + * + * Since: 2.10 + * Returns: the #GParamSpec that was passed into this function + */ +GParamSpec* +g_param_spec_ref_sink (GParamSpec *pspec) +{ + g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL); + g_return_val_if_fail (pspec->ref_count > 0, NULL); - return; - } - } - G_UNLOCK (pspec_ref_count); - } - else - { - G_UNLOCK (pspec_ref_count); - g_return_if_fail (pspec->ref_count > 0); - } + g_param_spec_ref (pspec); + g_param_spec_sink (pspec); + return pspec; } +/** + * g_param_spec_get_name: + * @pspec: a valid #GParamSpec + * + * Get the name of a #GParamSpec. + * + * Returns: the name of @pspec. + */ G_CONST_RETURN gchar* g_param_spec_get_name (GParamSpec *pspec) { @@ -241,24 +285,62 @@ g_param_spec_get_name (GParamSpec *pspec) return pspec->name; } +/** + * g_param_spec_get_nick: + * @pspec: a valid #GParamSpec + * + * Get the nickname of a #GParamSpec. + * + * Returns: the nickname of @pspec. + */ G_CONST_RETURN gchar* g_param_spec_get_nick (GParamSpec *pspec) { g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL); - return pspec->_nick ? pspec->_nick : pspec->name; + if (pspec->_nick) + return pspec->_nick; + else + { + GParamSpec *redirect_target; + + redirect_target = g_param_spec_get_redirect_target (pspec); + if (redirect_target && redirect_target->_nick) + return redirect_target->_nick; + } + + return pspec->name; } +/** + * g_param_spec_get_blurb: + * @pspec: a valid #GParamSpec + * + * Get the short description of a #GParamSpec. + * + * Returns: the short description of @pspec. + */ G_CONST_RETURN gchar* g_param_spec_get_blurb (GParamSpec *pspec) { g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL); - return pspec->_blurb; + if (pspec->_blurb) + return pspec->_blurb; + else + { + GParamSpec *redirect_target; + + redirect_target = g_param_spec_get_redirect_target (pspec); + if (redirect_target && redirect_target->_blurb) + return redirect_target->_blurb; + } + + return NULL; } static void -canonalize_key (gchar *key) +canonicalize_key (gchar *key) { gchar *p; @@ -274,6 +356,52 @@ canonalize_key (gchar *key) } } +static gboolean +is_canonical (const gchar *key) +{ + const gchar *p; + + for (p = key; *p != 0; p++) + { + gchar c = *p; + + if (c != '-' && + (c < '0' || c > '9') && + (c < 'A' || c > 'Z') && + (c < 'a' || c > 'z')) + return FALSE; + } + + return TRUE; +} + +/** + * g_param_spec_internal: + * @param_type: the #GType for the property; must be derived from #G_TYPE_PARAM + * @name: the canonical name of the property + * @nick: the nickname of the property + * @blurb: a short description of the property + * @flags: a combination of #GParamFlags + * + * Creates a new #GParamSpec instance. + * + * A property name consists of segments consisting of ASCII letters and + * digits, separated by either the '-' or '_' character. The first + * character of a property name must be a letter. Names which violate these + * rules lead to undefined behaviour. + * + * When creating and looking up a #GParamSpec, either separator can be used, + * but they cannot be mixed. Using '-' is considerably more efficient and in + * fact required when using property names as detail strings for signals. + * + * Beyond the name, #GParamSpecs have two more descriptive strings + * associated with them, the @nick, which should be suitable for use as + * a label for the property in a property editor, and the @blurb, which should + * be a somewhat longer description, suitable for e.g. a tooltip. The @nick + * and @blurb should ideally be localized. + * + * Returns: a newly allocated #GParamSpec instance + */ gpointer g_param_spec_internal (GType param_type, const gchar *name, @@ -286,17 +414,47 @@ g_param_spec_internal (GType param_type, g_return_val_if_fail (G_TYPE_IS_PARAM (param_type) && param_type != G_TYPE_PARAM, NULL); g_return_val_if_fail (name != NULL, NULL); g_return_val_if_fail ((name[0] >= 'A' && name[0] <= 'Z') || (name[0] >= 'a' && name[0] <= 'z'), NULL); + g_return_val_if_fail (!(flags & G_PARAM_STATIC_NAME) || is_canonical (name), NULL); pspec = (gpointer) g_type_create_instance (param_type); - pspec->name = g_strdup (name); - canonalize_key (pspec->name); - pspec->_nick = g_strdup (nick); - pspec->_blurb = g_strdup (blurb); + + if (flags & G_PARAM_STATIC_NAME) + { + pspec->name = g_intern_static_string (name); + if (!is_canonical (pspec->name)) + g_warning ("G_PARAM_STATIC_NAME used with non-canonical pspec name: %s", pspec->name); + } + else + { + pspec->name = g_strdup (name); + canonicalize_key (pspec->name); + g_intern_string (pspec->name); + } + + if (flags & G_PARAM_STATIC_NICK) + pspec->_nick = (gchar*) nick; + else + pspec->_nick = g_strdup (nick); + + if (flags & G_PARAM_STATIC_BLURB) + pspec->_blurb = (gchar*) blurb; + else + pspec->_blurb = g_strdup (blurb); + pspec->flags = (flags & G_PARAM_USER_MASK) | (flags & G_PARAM_MASK); return pspec; } +/** + * g_param_spec_get_qdata: + * @pspec: a valid #GParamSpec + * @quark: a #GQuark, naming the user data pointer + * + * Gets back user data pointers stored via g_param_spec_set_qdata(). + * + * Returns: the user data pointer set, or %NULL + */ gpointer g_param_spec_get_qdata (GParamSpec *pspec, GQuark quark) @@ -306,6 +464,19 @@ g_param_spec_get_qdata (GParamSpec *pspec, return quark ? g_datalist_id_get_data (&pspec->qdata, quark) : NULL; } +/** + * g_param_spec_set_qdata: + * @pspec: the #GParamSpec to set store a user data pointer + * @quark: a #GQuark, naming the user data pointer + * @data: an opaque user data pointer + * + * Sets an opaque, named pointer on a #GParamSpec. The name is specified + * through a #GQuark (retrieved e.g. via g_quark_from_static_string()), and + * the pointer can be gotten back from the @pspec with g_param_spec_get_qdata(). + * Setting a previously set user data pointer, overrides (frees) + * the old pointer set, using %NULL as pointer essentially + * removes the data stored. + */ void g_param_spec_set_qdata (GParamSpec *pspec, GQuark quark, @@ -317,6 +488,20 @@ g_param_spec_set_qdata (GParamSpec *pspec, g_datalist_id_set_data (&pspec->qdata, quark, data); } +/** + * g_param_spec_set_qdata_full: + * @pspec: the #GParamSpec to set store a user data pointer + * @quark: a #GQuark, naming the user data pointer + * @data: an opaque user data pointer + * @destroy: function to invoke with @data as argument, when @data needs to + * be freed + * + * This function works like g_param_spec_set_qdata(), but in addition, + * a void (*destroy) (gpointer) function may be + * specified which is called with @data as argument when the @pspec is + * finalized, or the data is being overwritten by a call to + * g_param_spec_set_qdata() with the same @quark. + */ void g_param_spec_set_qdata_full (GParamSpec *pspec, GQuark quark, @@ -329,6 +514,19 @@ g_param_spec_set_qdata_full (GParamSpec *pspec, g_datalist_id_set_data_full (&pspec->qdata, quark, data, data ? destroy : (GDestroyNotify) NULL); } +/** + * g_param_spec_steal_qdata: + * @pspec: the #GParamSpec to get a stored user data pointer from + * @quark: a #GQuark, naming the user data pointer + * + * Gets back user data pointers stored via g_param_spec_set_qdata() and + * removes the @data from @pspec without invoking it's destroy() function + * (if any was set). + * Usually, calling this function is only required to update + * user data pointers with a destroy notifier. + * + * Returns: the user data pointer set, or %NULL + */ gpointer g_param_spec_steal_qdata (GParamSpec *pspec, GQuark quark) @@ -339,6 +537,44 @@ g_param_spec_steal_qdata (GParamSpec *pspec, return g_datalist_id_remove_no_notify (&pspec->qdata, quark); } +/** + * g_param_spec_get_redirect_target: + * @pspec: a #GParamSpec + * + * If the paramspec redirects operations to another paramspec, + * returns that paramspec. Redirect is used typically for + * providing a new implementation of a property in a derived + * type while preserving all the properties from the parent + * type. Redirection is established by creating a property + * of type #GParamSpecOverride. See g_object_class_override_property() + * for an example of the use of this capability. + * + * Since: 2.4 + * Returns: paramspec to which requests on this paramspec should + * be redirected, or %NULL if none. + */ +GParamSpec* +g_param_spec_get_redirect_target (GParamSpec *pspec) +{ + g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL); + + if (G_IS_PARAM_SPEC_OVERRIDE (pspec)) + { + GParamSpecOverride *ospec = G_PARAM_SPEC_OVERRIDE (pspec); + + return ospec->overridden; + } + else + return NULL; +} + +/** + * g_param_value_set_default: + * @pspec: a valid #GParamSpec + * @value: a #GValue of correct type for @pspec + * + * Sets @value to its default value as specified in @pspec. + */ void g_param_value_set_default (GParamSpec *pspec, GValue *value) @@ -351,6 +587,15 @@ g_param_value_set_default (GParamSpec *pspec, G_PARAM_SPEC_GET_CLASS (pspec)->value_set_default (pspec, value); } +/** + * g_param_value_defaults: + * @pspec: a valid #GParamSpec + * @value: a #GValue of correct type for @pspec + * + * Checks whether @value contains the default value as specified in @pspec. + * + * Returns: whether @value contains the canonical default for this @pspec + */ gboolean g_param_value_defaults (GParamSpec *pspec, GValue *value) @@ -370,6 +615,20 @@ g_param_value_defaults (GParamSpec *pspec, return defaults; } +/** + * g_param_value_validate: + * @pspec: a valid #GParamSpec + * @value: a #GValue of correct type for @pspec + * + * Ensures that the contents of @value comply with the specifications + * set out by @pspec. For example, a #GParamSpecInt might require + * that integers stored in @value may not be smaller than -42 and not be + * greater than +42. If @value contains an integer outside of this range, + * it is modified accordingly, so the resulting value will fit into the + * range -42 .. +42. + * + * Returns: whether modifying @value was necessary to ensure validity + */ gboolean g_param_value_validate (GParamSpec *pspec, GValue *value) @@ -390,6 +649,24 @@ g_param_value_validate (GParamSpec *pspec, return FALSE; } +/** + * g_param_value_convert: + * @pspec: a valid #GParamSpec + * @src_value: souce #GValue + * @dest_value: destination #GValue of correct type for @pspec + * @strict_validation: %TRUE requires @dest_value to conform to @pspec without modifications + * + * Transforms @src_value into @dest_value if possible, and then validates + * @dest_value, in order for it to conform to @pspec. + * If @strict_validation is %TRUE this function will only succeed if + * the transformed @dest_value complied to @pspec without modifications. + * + * See also g_value_type_transformable(), g_value_transform() and + * g_param_value_validate(). + * + * Returns: %TRUE if transformation and validation were successful, + * %FALSE otherwise and @dest_value is left untouched. + */ gboolean g_param_value_convert (GParamSpec *pspec, const GValue *src_value, @@ -424,6 +701,18 @@ g_param_value_convert (GParamSpec *pspec, } } +/** + * g_param_values_cmp: + * @pspec: a valid #GParamSpec + * @value1: a #GValue of correct type for @pspec + * @value2: a #GValue of correct type for @pspec + * + * Compares @value1 with @value2 according to @pspec, and return -1, 0 or +1, + * if @value1 is found to be less than, equal to or greater than @value2, + * respectively. + * + * Returns: -1, 0 or +1, for a less than, equal to or greater than result + */ gint g_param_values_cmp (GParamSpec *pspec, const GValue *value1, @@ -541,6 +830,14 @@ value_param_lcopy_value (const GValue *value, /* --- param spec pool --- */ +/** + * GParamSpecPool: + * + * A #GParamSpecPool maintains a collection of #GParamSpecs which can be + * quickly accessed by owner and name. The implementation of the #GObject property + * system uses such a pool to store the #GParamSpecs of the properties all object + * types. + */ struct _GParamSpecPool { GStaticMutex smutex; @@ -572,6 +869,19 @@ param_spec_pool_equals (gconstpointer key_spec_1, strcmp (key1->name, key2->name) == 0); } +/** + * g_param_spec_pool_new: + * @type_prefixing: Whether the pool will support type-prefixed property names. + * + * Creates a new #GParamSpecPool. + * + * If @type_prefixing is %TRUE, lookups in the newly created pool will + * allow to specify the owner as a colon-separated prefix of the property name, + * like "GtkContainer:border-width". This feature is deprecated, so you should + * always set @type_prefixing to %FALSE. + * + * Returns: a newly allocated #GParamSpecPool. + */ GParamSpecPool* g_param_spec_pool_new (gboolean type_prefixing) { @@ -585,7 +895,14 @@ g_param_spec_pool_new (gboolean type_prefixing) return pool; } -void +/** + * g_param_spec_pool_insert: + * @pool: a #GParamSpecPool. + * @pspec: the #GParamSpec to insert + * @owner_type: a #GType identifying the owner of @pspec + * + * Inserts a #GParamSpec in the pool. + */void g_param_spec_pool_insert (GParamSpecPool *pool, GParamSpec *pspec, GType owner_type) @@ -619,6 +936,13 @@ g_param_spec_pool_insert (GParamSpecPool *pool, } } +/** + * g_param_spec_pool_remove: + * @pool: a #GParamSpecPool + * @pspec: the #GParamSpec to remove + * + * Removes a #GParamSpec from the pool. + */ void g_param_spec_pool_remove (GParamSpecPool *pool, GParamSpec *pspec) @@ -661,13 +985,13 @@ param_spec_ht_lookup (GHashTable *hash_table, else pspec = g_hash_table_lookup (hash_table, &key); - if (!pspec) + if (!pspec && !is_canonical (param_name)) { /* try canonicalized form */ key.name = g_strdup (param_name); key.owner_type = owner_type; - canonalize_key (key.name); + canonicalize_key (key.name); if (walk_ancestors) do { @@ -688,6 +1012,18 @@ param_spec_ht_lookup (GHashTable *hash_table, return pspec; } +/** + * g_param_spec_pool_lookup: + * @pool: a #GParamSpecPool + * @param_name: the name to look for + * @owner_type: the owner to look for + * @walk_ancestors: If %TRUE, also try to find a #GParamSpec with @param_name + * owned by an ancestor of @owner_type. + * + * Looks up a #GParamSpec in the pool. + * + * Returns: The found #GParamSpec, or %NULL if no matching #GParamSpec was found. + */ GParamSpec* g_param_spec_pool_lookup (GParamSpecPool *pool, const gchar *param_name, @@ -765,6 +1101,16 @@ pool_list (gpointer key, data[0] = g_list_prepend (data[0], pspec); } +/** + * g_param_spec_pool_list_owned: + * @pool: a #GParamSpecPool + * @owner_type: the owner to look for + * + * Gets an #GList of all #GParamSpecs owned by @owner_type in the pool. + * + * Returns: a #GList of all #GParamSpecs owned by @owner_type in + * the pool#GParamSpecs. + */ GList* g_param_spec_pool_list_owned (GParamSpecPool *pool, GType owner_type) @@ -793,10 +1139,10 @@ pspec_compare_id (gconstpointer a, } static inline GSList* -pspec_list_remove_overridden (GSList *plist, - GHashTable *ht, - GType owner_type, - guint *n_p) +pspec_list_remove_overridden_and_redirected (GSList *plist, + GHashTable *ht, + GType owner_type, + guint *n_p) { GSList *rlist = NULL; @@ -804,9 +1150,31 @@ pspec_list_remove_overridden (GSList *plist, { GSList *tmp = plist->next; GParamSpec *pspec = plist->data; + GParamSpec *found; + gboolean remove = FALSE; + + /* Remove paramspecs that are redirected, and also paramspecs + * that have are overridden by non-redirected properties. + * The idea is to get the single paramspec for each name that + * best corresponds to what the application sees. + */ + if (g_param_spec_get_redirect_target (pspec)) + remove = TRUE; + else + { + found = param_spec_ht_lookup (ht, pspec->name, owner_type, TRUE); + if (found != pspec) + { + GParamSpec *redirect = g_param_spec_get_redirect_target (found); + if (redirect != pspec) + remove = TRUE; + } + } - if (param_spec_ht_lookup (ht, pspec->name, owner_type, TRUE) != pspec) - g_slist_free_1 (plist); + if (remove) + { + g_slist_free_1 (plist); + } else { plist->next = rlist; @@ -830,13 +1198,54 @@ pool_depth_list (gpointer key, if (g_type_is_a (owner_type, pspec->owner_type)) { - guint d = g_type_depth (pspec->owner_type); + if (G_TYPE_IS_INTERFACE (pspec->owner_type)) + { + slists[0] = g_slist_prepend (slists[0], pspec); + } + else + { + guint d = g_type_depth (pspec->owner_type); - slists[d - 1] = g_slist_prepend (slists[d - 1], pspec); + slists[d - 1] = g_slist_prepend (slists[d - 1], pspec); + } } } -GParamSpec** /* free result */ +/* We handle interfaces specially since we don't want to + * count interface prerequisites like normal inheritance; + * the property comes from the direct inheritance from + * the prerequisite class, not from the interface that + * prerequires it. + * + * also 'depth' isn't a meaningful concept for interface + * prerequites. + */ +static void +pool_depth_list_for_interface (gpointer key, + gpointer value, + gpointer user_data) +{ + GParamSpec *pspec = value; + gpointer *data = user_data; + GSList **slists = data[0]; + GType owner_type = (GType) data[1]; + + if (pspec->owner_type == owner_type) + slists[0] = g_slist_prepend (slists[0], pspec); +} + +/** + * g_param_spec_pool_list: + * @pool: a #GParamSpecPool + * @owner_type: the owner to look for + * @n_pspecs_p: return location for the length of the returned array + * + * Gets an array of all #GParamSpecs owned by @owner_type in the pool. + * + * Returns: a newly allocated array containing pointers to all + * #GParamSpecs owned by @owner_type in the pool + */ +GParamSpec** g_param_spec_pool_list (GParamSpecPool *pool, GType owner_type, guint *n_pspecs_p) @@ -856,10 +1265,15 @@ g_param_spec_pool_list (GParamSpecPool *pool, slists = g_new0 (GSList*, d); data[0] = slists; data[1] = (gpointer) owner_type; - g_hash_table_foreach (pool->hash_table, pool_depth_list, &data); - for (i = 0; i < d - 1; i++) - slists[i] = pspec_list_remove_overridden (slists[i], pool->hash_table, owner_type, n_pspecs_p); - *n_pspecs_p += g_slist_length (slists[i]); + + g_hash_table_foreach (pool->hash_table, + G_TYPE_IS_INTERFACE (owner_type) ? + pool_depth_list_for_interface : + pool_depth_list, + &data); + + for (i = 0; i < d; i++) + slists[i] = pspec_list_remove_overridden_and_redirected (slists[i], pool->hash_table, owner_type, n_pspecs_p); pspecs = g_new (GParamSpec*, *n_pspecs_p + 1); p = pspecs; for (i = 0; i < d; i++) @@ -924,6 +1338,18 @@ default_values_cmp (GParamSpec *pspec, return memcmp (&value1->data, &value2->data, sizeof (value1->data)); } +/** + * g_param_type_register_static: + * @name: 0-terminated string used as the name of the new #GParamSpec type. + * @pspec_info: The #GParamSpecTypeInfo for this #GParamSpec type. + * + * Registers @name as the name of a new static type derived from + * #G_TYPE_PARAM. The type system uses the information contained in the + * #GParamSpecTypeInfo structure pointed to by @info to manage the #GParamSpec + * type and its instances. + * + * Returns: The new type identifier. + */ GType g_param_type_register_static (const gchar *name, const GParamSpecTypeInfo *pspec_info) @@ -964,6 +1390,13 @@ g_param_type_register_static (const gchar *name, return g_type_register_static (G_TYPE_PARAM, name, &info, 0); } +/** + * g_value_set_param: + * @value: a valid #GValue of type %G_TYPE_PARAM + * @param: the #GParamSpec to be set + * + * Set the contents of a %G_TYPE_PARAM #GValue to @param. + */ void g_value_set_param (GValue *value, GParamSpec *param) @@ -979,10 +1412,37 @@ g_value_set_param (GValue *value, g_param_spec_ref (value->data[0].v_pointer); } +/** + * g_value_set_param_take_ownership: + * @value: a valid #GValue of type %G_TYPE_PARAM + * @param: the #GParamSpec to be set + * + * This is an internal function introduced mainly for C marshallers. + * + * Deprecated: 2.4: Use g_value_take_param() instead. + */ void g_value_set_param_take_ownership (GValue *value, GParamSpec *param) { + g_value_take_param (value, param); +} + +/** + * g_value_take_param: + * @value: a valid #GValue of type %G_TYPE_PARAM + * @param: the #GParamSpec to be set + * + * Sets the contents of a %G_TYPE_PARAM #GValue to @param and + * takes over the ownership of the callers reference to @param; + * the caller doesn't have to unref it any more. + * + * Since: 2.4 + */ +void +g_value_take_param (GValue *value, + GParamSpec *param) +{ g_return_if_fail (G_VALUE_HOLDS_PARAM (value)); if (param) g_return_if_fail (G_IS_PARAM_SPEC (param)); @@ -992,6 +1452,14 @@ g_value_set_param_take_ownership (GValue *value, value->data[0].v_pointer = param; /* we take over the reference count */ } +/** + * g_value_get_param: + * @value: a valid #GValue whose type is derived from %G_TYPE_PARAM + * + * Get the contents of a %G_TYPE_PARAM #GValue. + * + * Returns: #GParamSpec content of @value + */ GParamSpec* g_value_get_param (const GValue *value) { @@ -1000,6 +1468,14 @@ g_value_get_param (const GValue *value) return value->data[0].v_pointer; } +/** + * g_value_dup_param: + * @value: a valid #GValue whose type is derived from %G_TYPE_PARAM + * + * Get the contents of a %G_TYPE_PARAM #GValue, increasing its reference count. + * + * Returns: #GParamSpec content of @value, should be unreferenced when no longer needed. + */ GParamSpec* g_value_dup_param (const GValue *value) { @@ -1007,3 +1483,6 @@ g_value_dup_param (const GValue *value) return value->data[0].v_pointer ? g_param_spec_ref (value->data[0].v_pointer) : NULL; } + +#define __G_PARAM_C__ +#include "gobjectaliasdef.c"